<?xml version="1.0" encoding="utf-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
  "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
<head>
  <title></title>
  <link href="../Styles/stylesheet.css" rel="stylesheet" type="text/css" />
  
<style type="text/css">
@page { margin-bottom: 5.000000pt; margin-top: 5.000000pt; }
</style>
</head>

<body>
  <h2><span style="border-bottom:1px solid">Chapter_6</span></h2>

  <p>查每个数组的访问，所以会消耗一定的时间和多余的代码量，而且没有办法把它关闭。这意味着数组访问可能成为程序效率低下的重要原因――如果它们在关键的场合进行。但考虑到因特网访问的安全，以及程序员的编程效率，Java设计人员还是应该把它看作是值得的。</p>

  <p>程序编写期间，如果不知道在自己的数组里需要多少元素，那么又该怎么办呢？此时，只需简单地用new在数组里创建元素。在这里，即使准备创建的是一个基本数据类型的数组，new也能正常地工作（new不会创建非数组的基本类型）：</p>

  <p>//: ArrayNew.java</p>

  <p>// Creating arrays with new.</p>

  <p>import java.util.*;</p>

  <p>public class ArrayNew {</p>

  <p>static Random rand = new Random();</p>

  <p>static int pRand(int mod) {</p>

  <p>return Math.abs(rand.nextInt()) % mod + 1;</p>

  <p>}</p>

  <p>public static void main(String[] args) {</p>

  <p>int[] a;</p>

  <p>a = new int[pRand(20)];</p>

  <p>prt("length of a = " + a.length);</p>

  <p>for(int i = 0; i &lt; a.length; i++)</p>

  <p>prt("a[" + i + "] = " + a[i]);</p>

  <p>}</p>

  <p>static void prt(String s) {</p>

  <p>System.out.println(s);</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>由于数组的大小是随机决定的（使用早先定义的pRand()方法），所以非常明显，数组的创建实际是在运行期间进行的。除此以外，从这个程序的输出中，大家可看到基本数据类型的数组元素会自动初始化成“空”值（对于数值，空值就是零；对于char，它是null；而对于boolean，它却是false）。</p>

  <p>当然，数组可能已在相同的语句中定义和初始化了，如下所示：</p>

  <p>int[] a = new int[pRand(20)];</p>

  <p>若操作的是一个非基本类型对象的数组，那么无论如何都要使用new。在这里，我们会再一次遇到句柄问题，因为我们创建的是一个句柄数组。请大家观察封装器类型Integer，它是一个类，而非基本数据类型：</p>

  <p>//: ArrayClassObj.java</p>

  <p>// Creating an array of non-primitive objects.</p>

  <p>import java.util.*;</p>

  <p>public class ArrayClassObj {</p>

  <p>static Random rand = new Random();</p>

  <p>static int pRand(int mod) {</p>

  <p>return Math.abs(rand.nextInt()) % mod + 1;</p>

  <p>}</p>

  <p>public static void main(String[] args) {</p>

  <p>Integer[] a = new Integer[pRand(20)];</p>

  <p>prt("length of a = " + a.length);</p>

  <p>for(int i = 0; i &lt; a.length; i++) {</p>

  <p>a[i] = new Integer(pRand(500));</p>

  <p>prt("a[" + i + "] = " + a[i]);</p>

  <p>}</p>

  <p>}</p>

  <p>static void prt(String s) {</p>

  <p>System.out.println(s);</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>在这儿，甚至在new调用后才开始创建数组：</p>

  <p>Integer[] a = new Integer[pRand(20)];</p>

  <p>它只是一个句柄数组，而且除非通过创建一个新的Integer对象，从而初始化了对象句柄，否则初始化进程不会结束：</p>

  <p>a[i] = new Integer(pRand(500));</p>

  <p>但若忘记创建对象，就会在运行期试图读取空数组位置时获得一个“违例”错误。</p>

  <p>下面让我们看看打印语句中String对象的构成情况。大家可看到指向Integer对象的句柄会自动转换，从而产生一个String，它代表着位于对象内部的值。</p>

  <p>亦可用花括号封闭列表来初始化对象数组。可采用两种形式，第一种是Java 1.0允许的唯一形式。第二种（等价）形式自Java 1.1才开始提供支持：</p>

  <p>//: ArrayInit.java</p>

  <p>// Array initialization</p>

  <p>public class ArrayInit {</p>

  <p>public static void main(String[] args) {</p>

  <p>Integer[] a = {</p>

  <p>new Integer(1),</p>

  <p>new Integer(2),</p>

  <p>new Integer(3),</p>

  <p>};</p>

  <p>// Java 1.1 only:</p>

  <p>Integer[] b = new Integer[] {</p>

  <p>new Integer(1),</p>

  <p>new Integer(2),</p>

  <p>new Integer(3),</p>

  <p>};</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>这种做法大多数时候都很有用，但限制也是最大的，因为数组的大小是在编译期间决定的。初始化列表的最后一个逗号是可选的（这一特性使长列表的维护变得更加容易）。</p>

  <p>数组初始化的第二种形式（Java 1.1开始支持）提供了一种更简便的语法，可创建和调用方法，获得与C的“变量参数列表”（C通常把它简称为“变参表”）一致的效果。这些效果包括未知的参数（自变量）数量以及未知的类型（如果这样选择的话）。由于所有类最终都是从通用的根类Object中继承的，所以能创建一个方法，令其获取一个Object数组，并象下面这样调用它：</p>

  <p>//: VarArgs.java</p>

  <p>// Using the Java 1.1 array syntax to create</p>

  <p>// variable argument lists</p>

  <p>class A { int i; }</p>

  <p>public class VarArgs {</p>

  <p>static void f(Object[] x) {</p>

  <p>for(int i = 0; i &lt; x.length; i++)</p>

  <p>System.out.println(x[i]);</p>

  <p>}</p>

  <p>public static void main(String[] args) {</p>

  <p>f(new Object[] {</p>

  <p>new Integer(47), new VarArgs(),</p>

  <p>new Float(3.14), new Double(11.11) });</p>

  <p>f(new Object[] {"one", "two", "three" });</p>

  <p>f(new Object[] {new A(), new A(), new A()});</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>此时，我们对这些未知的对象并不能采取太多的操作，而且这个程序利用自动String转换对每个Object做一些有用的事情。在第11章（运行期类型标识或RTTI），大家还会学习如何调查这类对象的准确类型，使自己能对它们做一些有趣的事情。</p>

  <p>4.5.1 多维数组</p>

  <p>在Java里可以方便地创建多维数组：</p>

  <p>//: MultiDimArray.java</p>

  <p>// Creating multidimensional arrays.</p>

  <p>import java.util.*;</p>

  <p>public class MultiDimArray {</p>

  <p>static Random rand = new Random();</p>

  <p>static int pRand(int mod) {</p>

  <p>return Math.abs(rand.nextInt()) % mod + 1;</p>

  <p>}</p>

  <p>public static void main(String[] args) {</p>

  <p>int[][] a1 = {</p>

  <p>{ 1, 2, 3, },</p>

  <p>{ 4, 5, 6, },</p>

  <p>};</p>

  <p>for(int i = 0; i &lt; a1.length; i++)</p>

  <p>for(int j = 0; j &lt; a1[i].length; j++)</p>

  <p>prt("a1[" + i + "][" + j +</p>

  <p>"] = " + a1[i][j]);</p>

  <p>// 3-D array with fixed length:</p>

  <p>int[][][] a2 = new int[2][2][4];</p>

  <p>for(int i = 0; i &lt; a2.length; i++)</p>

  <p>for(int j = 0; j &lt; a2[i].length; j++)</p>

  <p>for(int k = 0; k &lt; a2[i][j].length;</p>

  <p>k++)</p>

  <p>prt("a2[" + i + "][" +</p>

  <p>j + "][" + k +</p>

  <p>"] = " + a2[i][j][k]);</p>

  <p>// 3-D array with varied-length vectors:</p>

  <p>int[][][] a3 = new int[pRand(7)][][];</p>

  <p>for(int i = 0; i &lt; a3.length; i++) {</p>

  <p>a3[i] = new int[pRand(5)][];</p>

  <p>for(int j = 0; j &lt; a3[i].length; j++)</p>

  <p>a3[i][j] = new int[pRand(5)];</p>

  <p>}</p>

  <p>for(int i = 0; i &lt; a3.length; i++)</p>

  <p>for(int j = 0; j &lt; a3[i].length; j++)</p>

  <p>for(int k = 0; k &lt; a3[i][j].length;</p>

  <p>k++)</p>

  <p>prt("a3[" + i + "][" +</p>

  <p>j + "][" + k +</p>

  <p>"] = " + a3[i][j][k]);</p>

  <p>// Array of non-primitive objects:</p>

  <p>Integer[][] a4 = {</p>

  <p>{ new Integer(1), new Integer(2)},</p>

  <p>{ new Integer(3), new Integer(4)},</p>

  <p>{ new Integer(5), new Integer(6)},</p>

  <p>};</p>

  <p>for(int i = 0; i &lt; a4.length; i++)</p>

  <p>for(int j = 0; j &lt; a4[i].length; j++)</p>

  <p>prt("a4[" + i + "][" + j +</p>

  <p>"] = " + a4[i][j]);</p>

  <p>Integer[][] a5;</p>

  <p>a5 = new Integer[3][];</p>

  <p>for(int i = 0; i &lt; a5.length; i++) {</p>

  <p>a5[i] = new Integer[3];</p>

  <p>for(int j = 0; j &lt; a5[i].length; j++)</p>

  <p>a5[i][j] = new Integer(i*j);</p>

  <p>}</p>

  <p>for(int i = 0; i &lt; a5.length; i++)</p>

  <p>for(int j = 0; j &lt; a5[i].length; j++)</p>

  <p>prt("a5[" + i + "][" + j +</p>

  <p>"] = " + a5[i][j]);</p>

  <p>}</p>

  <p>static void prt(String s) {</p>

  <p>System.out.println(s);</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>用于打印的代码里使用了length，所以它不必依赖固定的数组大小。</p>

  <p>第一个例子展示了基本数据类型的一个多维数组。我们可用花括号定出数组内每个矢量的边界：</p>

  <p>int[][] a1 = {</p>

  <p>{ 1, 2, 3, },</p>

  <p>{ 4, 5, 6, },</p>

  <p>};</p>

  <p>每个方括号对都将我们移至数组的下一级。</p>

  <p>第二个例子展示了用new分配的一个三维数组。在这里，整个数组都是立即分配的：</p>

  <p>int[][][] a2 = new int[2][2][4];</p>

  <p>但第三个例子却向大家揭示出构成矩阵的每个矢量都可以有任意的长度：</p>

  <p>int[][][] a3 = new int[pRand(7)][][];</p>

  <p>for(int i = 0; i &lt; a3.length; i++) {</p>

  <p>a3[i] = new int[pRand(5)][];</p>

  <p>for(int j = 0; j &lt; a3[i].length; j++)</p>

  <p>a3[i][j] = new int[pRand(5)];</p>

  <p>}</p>

  <p>对于第一个new创建的数组，它的第一个元素的长度是随机的，其他元素的长度则没有定义。for循环内的第二个new则会填写元素，但保持第三个索引的未定状态――直到碰到第三个new。</p>

  <p>根据输出结果，大家可以看到：假若没有明确指定初始化值，数组值就会自动初始化成零。</p>

  <p>可用类似的表式处理非基本类型对象的数组。这从第四个例子可以看出，它向我们演示了用花括号收集多个new表达式的能力：</p>

  <p>Integer[][] a4 = {</p>

  <p>{ new Integer(1), new Integer(2)},</p>

  <p>{ new Integer(3), new Integer(4)},</p>

  <p>{ new Integer(5), new Integer(6)},</p>

  <p>};</p>

  <p>第五个例子展示了如何逐渐构建非基本类型的对象数组：</p>

  <p>Integer[][] a5;</p>

  <p>a5 = new Integer[3][];</p>

  <p>for(int i = 0; i &lt; a5.length; i++) {</p>

  <p>a5[i] = new Integer[3];</p>

  <p>for(int j = 0; j &lt; a5[i].length; j++)</p>

  <p>a5[i][j] = new Integer(i*j);</p>

  <p>}</p>

  <p>i*j只是在Integer里置了一个有趣的值。</p>

  <p>4.6 总结</p>

  <p>作为初始化的一种具体操作形式，构建器应使大家明确感受到在语言中进行初始化的重要性。与C++的程序设计一样，判断一个程序效率如何，关键是看是否由于变量的初始化不正确而造成了严重的编程错误（臭虫）。这些形式的错误很难发现，而且类似的问题也适用于不正确的清除或收尾工作。由于构建器使我们能保证正确的初始化和清除（若没有正确的构建器调用，编译器不允许对象创建），所以能获得完全的控制权和安全性。</p>

  <p>在C++中，与“构建”相反的“破坏”（Destruction）工作也是相当重要的，因为用new创建的对象必须明确地清除。在Java中，垃圾收集器会自动为所有对象释放内存，所以Java中等价的清除方法并不是经常都需要用到的。如果不需要类似于构建器的行为，Java的垃圾收集器可以极大简化编程工作，而且在内存的管理过程中增加更大的安全性。有些垃圾收集器甚至能清除其他资源，比如图形和文件句柄等。然而，垃圾收集器确实也增加了运行期的开销。但这种开销到底造成了多大的影响却是很难看出的，因为到目前为止，Java解释器的总体运行速度仍然是比较慢的。随着这一情况的改观，我们应该能判断出垃圾收集器的开销是否使Java不适合做一些特定的工作（其中一个问题是垃圾收集器不可预测的性质）。</p>

  <p>由于所有对象都肯定能获得正确的构建，所以同这儿讲述的情况相比，构建器实际做的事情还要多得多。特别地，当我们通过“创作”或“继承”生成新类的时候，对构建的保证仍然有效，而且需要一些附加的语法来提供对它的支持。大家将在以后的章节里详细了解创作、继承以及它们对构建器造成的影响。</p>

  <p>4.7 练习</p>

  <p>(1) 用默认构建器创建一个类（没有自变量），用它打印一条消息。创建属于这个类的一个对象。</p>

  <p>(2) 在练习1的基础上增加一个过载的构建器，令其采用一个String自变量，并随同自己的消息打印出来。</p>

  <p>(3) 以练习2创建的类为基础上，创建属于它的对象句柄的一个数组，但不要实际创建对象并分配到数组里。运行程序时，注意是否打印出来自构建器调用的初始化消息。</p>

  <p>(4) 创建同句柄数组联系起来的对象，最终完成练习3。</p>

  <p>(5) 用自变量“before”，“after”和“none”运行程序，试验Garbage.java。重复这个操作，观察是否从输出中看出了一些固定的模式。改变代码，使System.runFinalization()在System.gc()之前调用，再观察结果。</p>

  <p>英文版主页 | 中文版主页 | 详细目录 | 关于译者</p>

  <p>-------------------------------------------------</p>

  <p>TXT书库 www.16txt.com</p>

  <p>-------------------------------------------------第5章 隐藏实施过程</p>

  <p>“进行面向对象的设计时，一项基本的考虑是：如何将发生变化的东西与保持不变的东西分隔开。”</p>

  <p>这一点对于库来说是特别重要的。那个库的用户（客户程序员）必须能依赖自己使用的那一部分，并知道一旦新版本的库出台，自己不需要改写代码。而与此相反，库的创建者必须能自由地进行修改与改进，同时保证客户程序员代码不会受到那些变动的影响。</p>

  <p>为达到这个目的，需遵守一定的约定或规则。例如，库程序员在修改库内的一个类时，必须保证不删除已有的方法，因为那样做会造成客户程序员代码出现断点。然而，相反的情况却是令人痛苦的。对于一个数据成员，库的创建者怎样才能知道哪些数据成员已受到客户程序员的访问呢？若方法属于某个类唯一的一部分，而且并不一定由客户程序员直接使用，那么这种痛苦的情况同样是真实的。如果库的创建者想删除一种旧有的实施方案，并置入新代码，此时又该怎么办呢？对那些成员进行的任何改动都可能中断客户程序员的代码。所以库创建者处在一个尴尬的境地，似乎根本动弹不得。</p>

  <p>为解决这个问题，Java推出了“访问指示符”的概念，允许库创建者声明哪些东西是客户程序员可以使用的，哪些是不可使用的。这种访问控制的级别在“最大访问”和“最小访问”的范围之间，分别包括：public，“友好的”（无关键字），protected以及private。根据前一段的描述，大家或许已总结出作为一名库设计者，应将所有东西都尽可能保持为“private”（私有），并只展示出那些想让客户程序员使用的方法。这种思路是完全正确的，尽管它有点儿违背那些用其他语言（特别是C）编程的人的直觉，那些人习惯于在没有任何限制的情况下访问所有东西。到这一章结束时，大家应该可以深刻体会到Java访问控制的价值。</p>

  <p>然而，组件库以及控制谁能访问那个库的组件的概念现在仍不是完整的。仍存在这样一个问题：如何将组件绑定到单独一个统一的库单元里。这是通过Java的package（打包）关键字来实现的，而且访问指示符要受到类在相同的包还是在不同的包里的影响。所以在本章的开头，大家首先要学习库组件如何置入包里。这样才能理解访问指示符的完整含义。</p>

  <p>5.1 包：库单元</p>

  <p>我们用import关键字导入一个完整的库时，就会获得“包”（Package）。例如：</p>

  <p>import java.util.*;</p>

  <p>它的作用是导入完整的实用工具（Utility）库，该库属于标准Java开发工具包的一部分。由于Vector位于java.util里，所以现在要么指定完整名称“java.util.Vector”（可省略import语句），要么简单地指定一个“Vector”（因为import是默认的）。</p>

  <p>若想导入单独一个类，可在import语句里指定那个类的名字：</p>

  <p>import java.util.Vector;</p>

  <p>现在，我们可以自由地使用Vector。然而，java.util中的其他任何类仍是不可使用的。</p>

  <p>之所以要进行这样的导入，是为了提供一种特殊的机制，以便管理“命名空间”（Name Space）。我们所有类成员的名字相互间都会隔离起来。位于类A内的一个方法f()不会与位于类B内的、拥有相同“签名”（自变量列表）的f()发生冲突。但类名会不会冲突呢？假设创建一个stack类，将它安装到已有一个stack类（由其他人编写）的机器上，这时会出现什么情况呢？对于因特网中的Java应用，这种情况会在用户毫不知晓的时候发生，因为类会在运行一个Java程序的时候自动下载。</p>

  <p>正是由于存在名字潜在的冲突，所以特别有必要对Java中的命名空间进行完整的控制，而且需要创建一个完全独一无二的名字，无论因特网存在什么样的限制。</p>

  <p>迄今为止，本书的大多数例子都仅存在于单个文件中，而且设计成局部（本地）使用，没有同包名发生冲突（在这种情况下，类名置于“默认包”内）。这是一种有效的做法，而且考虑到问题的简化，本书剩下的部分也将尽可能地采用它。然而，若计划创建一个“对因特网友好”或者说“适合在因特网使用”的程序，必须考虑如何防止类名的重复。</p>

  <p>为Java创建一个源码文件的时候，它通常叫作一个“编辑单元”（有时也叫作“翻译单元”）。每个编译单元都必须有一个以.java结尾的名字。而且在编译单元的内部，可以有一个公共（public）类，它必须拥有与文件相同的名字（包括大小写形式，但排除.java文件扩展名）。如果不这样做，编译器就会报告出错。每个编译单元内都只能有一个public类（同样地，否则编译器会报告出错）。那个编译单元剩下的类（如果有的话）可在那个包外面的世界面前隐藏起来，因为它们并非“公共”的（非public），而且它们由用于主public类的“支撑”类组成。</p>

  <p>编译一个.java文件时，我们会获得一个名字完全相同的输出文件；但对于.java文件中的每个类，它们都有一个.class扩展名。因此，我们最终从少量的.java文件里有可能获得数量众多的.class文件。如以前用一种汇编语言写过程序，那么可能已习惯编译器先分割出一种过渡形式（通常是一个.obj文件），再用一个链接器将其与其他东西封装到一起（生成一个可执行文件），或者与一个库封装到一起（生成一个库）。但那并不是Java的工作方式。一个有效的程序就是一系列.class文件，它们可以封装和压缩到一个JAR文件里（使用Java 1.1提供的jar工具）。Java解释器负责对这些文件的寻找、装载和解释（注释①）。</p>

  <p>①：Java并没有强制一定要使用解释器。一些固有代码的Java编译器可生成单独的可执行文件。</p>

  <p>“库”也由一系列类文件构成。每个文件都有一个public类（并没强迫使用一个public类，但这种情况最很典型的），所以每个文件都有一个组件。如果想将所有这些组件（它们在各自独立的.java和.class文件里）都归纳到一起，那么package关键字就可以发挥作用）。</p>

  <p>若在一个文件的开头使用下述代码：</p>

  <p>package mypackage;</p>

  <p>那么package语句必须作为文件的第一个非注释语句出现。该语句的作用是指出这个编译单元属于名为mypackage的一个库的一部分。或者换句话说，它表明这个编译单元内的public类名位于mypackage这个名字的下面。如果其他人想使用这个名字，要么指出完整的名字，要么与mypackage联合使用import关键字（使用前面给出的选项）。注意根据Java包（封装）的约定，名字内的所有字母都应小写，甚至那些中间单词亦要如此。</p>

  <p>例如，假定文件名是MyClass.java。它意味着在那个文件有一个、而且只能有一个public类。而且那个类的名字必须是MyClass（包括大小写形式）：</p>

  <p>package mypackage;</p>

  <p>public class MyClass {</p>

  <p>// . . .</p>

  <p>现在，如果有人想使用MyClass，或者想使用mypackage内的其他任何public类，他们必须用import关键字激活mypackage内的名字，使它们能够使用。另一个办法则是指定完整的名称：</p>

  <p>mypackage.MyClass m = new mypackage.MyClass();</p>

  <p>import关键字则可将其变得简洁得多：</p>

  <p>import mypackage.*;</p>

  <p>// . . .</p>

  <p>MyClass m = new MyClass();</p>

  <p>作为一名库设计者，一定要记住package和import关键字允许我们做的事情就是分割单个全局命名空间，保证我们不会遇到名字的冲突――无论有多少人使用因特网，也无论多少人用Java编写自己的类。</p>

  <p>5.1.1 创建独一无二的包名</p>

  <p>大家或许已注意到这样一个事实：由于一个包永远不会真的“封装”到单独一个文件里面，它可由多个.class文件构成，所以局面可能稍微有些混乱。为避免这个问题，最合理的一种做法就是将某个特定包使用的所有.class文件都置入单个目录里。也就是说，我们要利用操作系统的分级文件结构避免出现混乱局面。这正是Java所采取的方法。</p>

  <p>它同时也解决了另两个问题：创建独一无二的包名以及找出那些可能深藏于目录结构某处的类。正如我们在第2章讲述的那样，为达到这个目的，需要将.class文件的位置路径编码到package的名字里。但根据约定，编译器强迫package名的第一部分是类创建者的因特网域名。由于因特网域名肯定是独一无二的（由InterNIC保证――注释②，它控制着域名的分配），所以假如按这一约定行事，package的名称就肯定不会重复，所以永远不会遇到名称冲突的问题。换句话说，除非将自己的域名转让给其他人，而且对方也按照相同的路径名编写Java代码，否则名字的冲突是永远不会出现的。当然，如果你没有自己的域名，那么必须创造一个非常生僻的包名（例如自己的英文姓名），以便尽最大可能创建一个独一无二的包名。如决定发行自己的Java代码，那么强烈推荐去申请自己的域名，它所需的费用是非常低廉的。</p>

  <p>②：ftp://ftp.internic.net</p>

  <p>这个技巧的另一部分是将package名解析成自己机器上的一个目录。这样一来，Java程序运行并需要装载.class文件的时候（这是动态进行的，在程序需要创建属于那个类的一个对象，或者首次访问那个类的一个static成员时），它就可以找到.class文件驻留的那个目录。</p>

  <p>Java解释器的工作程序如下：首先，它找到环境变量CLASSPATH（将Java或者具有Java解释能力的工具――如浏览器――安装到机器中时，通过操作系统进行设定）。CLASSPATH包含了一个或多个目录，它们作为一种特殊的“根”使用，从这里展开对.class文件的搜索。从那个根开始，解释器会寻找包名，并将每个点号（句点）替换成一个斜杠，从而生成从CLASSPATH根开始的一个路径名（所以package foo.bar.baz会变成foo\bar\baz或者foo/bar/baz；具体是正斜杠还是反斜杠由操作系统决定）。随后将它们连接到一起，成为CLASSPATH内的各个条目（入口）。以后搜索.class文件时，就可从这些地方开始查找与准备创建的类名对应的名字。此外，它也会搜索一些标准目录――这些目录与Java解释器驻留的地方有关。</p>

  <p>为进一步理解这个问题，下面以我自己的域名为例，它是bruceeckel.com。将其反转过来后，com.bruceeckel就为我的类创建了独一无二的全局名称（com，edu，org，net等扩展名以前在Java包中都是大写的，但自Java 1.2以来，这种情况已发生了变化。现在整个包名都是小写的）。由于决定创建一个名为util的库，我可以进一步地分割它，所以最后得到的包名如下：</p>

  <p>package com.bruceeckel.util;</p>

  <p>现在，可将这个包名作为下述两个文件的“命名空间”使用：//: Vector.java</p>

  <p>// Creating a package</p>

  <p>package com.bruceeckel.util;</p>

  <p>public class Vector {</p>

  <p>public Vector() {</p>

  <p>System.out.println(</p>

  <p>"com.bruceeckel.util.Vector");</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>创建自己的包时，要求package语句必须是文件中的第一个“非注释”代码。第二个文件表面看起来是类似的：</p>

  <p>//: List.java</p>

  <p>// Creating a package</p>

  <p>package com.bruceeckel.util;</p>

  <p>public class List {</p>

  <p>public List() {</p>

  <p>System.out.println(</p>

  <p>"com.bruceeckel.util.List");</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>这两个文件都置于我自己系统的一个子目录中：</p>

  <p>C:\DOC\JavaT\com\bruceeckel\util</p>

  <p>若通过它往回走，就会发现包名com.bruceeckel.util，但路径的第一部分又是什么呢？这是由CLASSPATH环境变量决定的。在我的机器上，它是：</p>

  <p>CLASSPATH=.;D:\JAVA\LIB;C:\DOC\JavaT</p>

  <p>可以看出，CLASSPATH里能包含大量备用的搜索路径。然而，使用JAR文件时要注意一个问题：必须将JAR文件的名字置于类路径里，而不仅仅是它所在的路径。所以对一个名为grape.jar的JAR文件来说，我们的类路径需要包括：</p>

  <p>CLASSPATH=.;D:\JAVA\LIB;C:\flavors\grape.jar</p>

  <p>正确设置好类路径后，可将下面这个文件置于任何目录里（若在执行该程序时遇到麻烦，请参见第3章的3.1.2小节“赋值”）：</p>

  <p>//: LibTest.java</p>

  <p>// Uses the library</p>

  <p>package c05;</p>

  <p>import com.bruceeckel.util.*;</p>

  <p>public class LibTest {</p>

  <p>public static void main(String[] args) {</p>

  <p>Vector v = new Vector();</p>

  <p>List l = new List();</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>编译器遇到import语句后，它会搜索由CLASSPATH指定的目录，查找子目录com\bruceeckel\util，然后查找名称适当的已编译文件（对于Vector是Vector.class，对于List则是List.class）。注意Vector和List内无论类还是需要的方法都必须设为public。</p>

  <p>1. 自动编译</p>

  <p>为导入的类首次创建一个对象时（或者访问一个类的static成员时），编译器会在适当的目录里寻找同名的.class文件（所以如果创建类X的一个对象，就应该是X.class）。若只发现X.class，它就是必须使用的那一个类。然而，如果它在相同的目录中还发现了一个X.java，编译器就会比较两个文件的日期标记。如果X.java比X.class新，就会自动编译X.java，生成一个最新的X.class。</p>

  <p>对于一个特定的类，或在与它同名的.java文件中没有找到它，就会对那个类采取上述的处理。</p>

  <p>2. 冲突</p>

  <p>若通过*导入了两个库，而且它们包括相同的名字，这时会出现什么情况呢？例如，假定一个程序使用了下述导入语句：</p>

  <p>import com.bruceeckel.util.*;</p>

  <p>import java.util.*;</p>

  <p>由于java.util.*也包含了一个Vector类，所以这会造成潜在的冲突。然而，只要冲突并不真的发生，那么就不会产生任何问题――这当然是最理想的情况，因为否则的话，就需要进行大量编程工作，防范那些可能可能永远也不会发生的冲突。</p>

  <p>如现在试着生成一个Vector，就肯定会发生冲突。如下所示：</p>

  <p>Vector v = new Vector();</p>

  <p>它引用的到底是哪个Vector类呢？编译器对这个问题没有答案，读者也不可能知道。所以编译器会报告一个错误，强迫我们进行明确的说明。例如，假设我想使用标准的Java Vector，那么必须象下面这样编程：</p>

  <p>java.util.Vector v = new java.util.Vector();</p>

  <p>由于它（与CLASSPATH一起）完整指定了那个Vector的位置，所以不再需要import java.util.*语句，除非还想使用来自java.util的其他东西。</p>

  <p>5.1.2 自定义工具库</p>

  <p>掌握前述的知识后，接下来就可以开始创建自己的工具库，以便减少或者完全消除重复的代码。例如，可为System.out.println()创建一个别名，减少重复键入的代码量。它可以是名为tools的一个包（package）的一部分：</p>

  <p>//: P.java</p>

  <p>// The P.rint &amp; P.rintln shorthand</p>

  <p>package com.bruceeckel.tools;</p>

  <p>public class P {</p>

  <p>public static void rint(Object obj) {</p>

  <p>System.out.print(obj);</p>

  <p>}</p>

  <p>public static void rint(String s) {</p>

  <p>System.out.print(s);</p>

  <p>}</p>

  <p>public static void rint(char[] s) {</p>

  <p>System.out.print(s);</p>

  <p>}</p>

  <p>public static void rint(char c) {</p>

  <p>System.out.print(c);</p>

  <p>}</p>

  <p>public static void rint(int i) {</p>

  <p>System.out.print(i);</p>

  <p>}</p>

  <p>public static void rint(long l) {</p>

  <p>System.out.print(l);</p>

  <p>}</p>

  <p>public static void rint(float f) {</p>

  <p>System.out.print(f);</p>

  <p>}</p>

  <p>public static void rint(double d) {</p>

  <p>System.out.print(d);</p>

  <p>}</p>

  <p>public static void rint(boolean b) {</p>

  <p>System.out.print(b);</p>

  <p>}</p>

  <p>public static void rintln() {</p>

  <p>System.out.println();</p>

  <p>}</p>

  <p>public static void rintln(Object obj) {</p>

  <p>System.out.println(obj);</p>

  <p>}</p>

  <p>public static void rintln(String s) {</p>

  <p>System.out.println(s);</p>

  <p>}</p>

  <p>public static void rintln(char[] s) {</p>

  <p>System.out.println(s);</p>

  <p>}</p>

  <p>public static void rintln(char c) {</p>

  <p>System.out.println(c);</p>

  <p>}</p>

  <p>public static void rintln(int i) {</p>

  <p>System.out.println(i);</p>

  <p>}</p>

  <p>public static void rintln(long l) {</p>

  <p>System.out.println(l);</p>

  <p>}</p>

  <p>public static void rintln(float f) {</p>

  <p>System.out.println(f);</p>

  <p>}</p>

  <p>public static void rintln(double d) {</p>

  <p>System.out.println(d);</p>

  <p>}</p>

  <p>public static void rintln(boolean b) {</p>

  <p>System.out.println(b);</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>所有不同的数据类型现在都可以在一个新行输出（P.rintln()），或者不在一个新行输出（P.rint()）。</p>

  <p>大家可能会猜想这个文件所在的目录必须从某个CLASSPATH位置开始，然后继续com/bruceeckel/tools。编译完毕后，利用一个import语句，即可在自己系统的任何地方使用P.class文件。如下所示：</p>

  <p>ToolTest.java</p>

  <p>所以从现在开始，无论什么时候只要做出了一个有用的新工具，就可将其加入tools目录（或者自己的个人util或tools目录）。</p>

  <p>1. CLASSPATH的陷阱</p>

  <p>P.java文件存在一个非常有趣的陷阱。特别是对于早期的Java实现方案来说，类路径的正确设定通常都是很困难的一项工作。编写这本书的时候，我引入了P.java文件，它最初看起来似乎工作很正常。但在某些情况下，却开始出现中断。在很长的时间里，我都确信这是Java或其他什么在实现时一个错误。但最后，我终于发现在一个地方引入了一个程序（即第17章要说明的CodePackager.java），它使用了一个不同的类P。由于它作为一个工具使用，所以有时候会进入类路径里；另一些时候则不会这样。但只要它进入类路径，那么假若执行的程序需要寻找com.bruceeckel.tools中的类，Java首先发现的就是CodePackager.java中的P。此时，编译器会报告一个特定的方法没有找到。这当然是非常令人头疼的，因为我们在前面的类P里明明看到了这个方法，而且根本没有更多的诊断报告可为我们提供一条线索，让我们知道找到的是一个完全不同的类（那甚至不是public的）。</p>

  <p>乍一看来，这似乎是编译器的一个错误，但假若考察import语句，就会发现它只是说：“在这里可能发现了P”。然而，我们假定的是编译器搜索自己类路径的任何地方，所以一旦它发现一个P，就会使用它；若在搜索过程中发现了“错误的”一个，它就会停止搜索。这与我们在前面表述的稍微有些区别，因为存在一些讨厌的类，它们都位于包内。而这里有一个不在包内的P，但仍可在常规的类路径搜索过程中找到。</p>

  <p>如果您遇到象这样的情况，请务必保证对于类路径的每个地方，每个名字都仅存在一个类。</p>

  <p>5.1.3 利用导入改变行为</p>

  <p>Java已取消的一种特性是C的“条件编译”，它允许我们改变参数，获得不同的行为，同时不改变其他任何代码。Java之所以抛弃了这一特性，可能是由于该特性经常在C里用于解决跨平台问题：代码的不同部分根据具体的平台进行编译，否则不能在特定的平台上运行。由于Java的设计思想是成为一种自动跨平台的语言，所以这种特性是没有必要的。</p>

  <p>然而，条件编译还有另一些非常有价值的用途。一种很常见的用途就是调试代码。调试特性可在开发过程中使用，但在发行的产品中却无此功能。Alen Holub（www.holub.com）提出了利用包（package）来模仿条件编译的概念。根据这一概念，它创建了C“断定机制”一个非常有用的Java版本。之所以叫作“断定机制”，是由于我们可以说“它应该为真”或者“它应该为假”。如果语句不同意你的断定，就可以发现相关的情况。这种工具在调试过程中是特别有用的。</p>

  <p>可用下面这个类进行程序调试：</p>

  <p>//: Assert.java</p>

  <p>// Assertion tool for debugging</p>

  <p>package com.bruceeckel.tools.debug;</p>

  <p>public class Assert {</p>

  <p>private static void perr(String msg) {</p>

  <p>System.err.println(msg);</p>

  <p>}</p>

  <p>public final static void is_true(boolean exp) {</p>

  <p>if(!exp) perr("Assertion failed");</p>

  <p>}</p>

  <p>public final static void is_false(boolean exp){</p>

  <p>if(exp) perr("Assertion failed");</p>

  <p>}</p>

  <p>public final static void</p>

  <p>is_true(boolean exp, String msg) {</p>

  <p>if(!exp) perr("Assertion failed: " + msg);</p>

  <p>}</p>

  <p>public final static void</p>

  <p>is_false(boolean exp, String msg) {</p>

  <p>if(exp) perr("Assertion failed: " + msg);</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>这个类只是简单地封装了布尔测试。如果失败，就显示出出错消息。在第9章，大家还会学习一个更高级的错误控制工具，名为“违例控制”。但在目前这种情况下，perr()方法已经可以很好地工作。</p>

  <p>如果想使用这个类，可在自己的程序中加入下面这一行：</p>

  <p>import com.bruceeckel.tools.debug.*;</p>

  <p>如欲清除断定机制，以便自己能发行最终的代码，我们创建了第二个Assert类，但却是在一个不同的包里：</p>

  <p>//: Assert.java</p>

  <p>// Turning off the assertion output</p>

  <p>// so you can ship the program.</p>

  <p>package com.bruceeckel.tools;</p>

  <p>public class Assert {</p>

  <p>public final static void is_true(boolean exp){}</p>

  <p>public final static void is_false(boolean exp){}</p>

  <p>public final static void</p>

  <p>is_true(boolean exp, String msg) {}</p>

  <p>public final static void</p>

  <p>is_false(boolean exp, String msg) {}</p>

  <p>} ///:~</p>

  <p>现在，假如将前一个import语句变成下面这个样子：</p>

  <p>import com.bruceeckel.tools.*;</p>

  <p>程序便不再显示出断言。下面是个例子：</p>

  <p>//: TestAssert.java</p>

  <p>// Demonstrating the assertion tool</p>

  <p>package c05;</p>

  <p>// Comment the following, and uncomment the</p>

  <p>// subsequent line to change assertion behavior:</p>

  <p>import com.bruceeckel.tools.debug.*;</p>

  <p>// import com.bruceeckel.tools.*;</p>

  <p>public class TestAssert {</p>

  <p>public static void main(String[] args) {</p>

  <p>Assert.is_true((2 + 2) == 5);</p>

  <p>Assert.is_false((1 + 1) == 2);</p>

  <p>Assert.is_true((2 + 2) == 5, "2 + 2 == 5");</p>

  <p>Assert.is_false((1 + 1) == 2, "1 +1 != 2");</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>通过改变导入的package，我们可将自己的代码从调试版本变成最终的发行版本。这种技术可应用于任何种类的条件代码。</p>

  <p>5.1.4 包的停用</p>

  <p>大家应注意这样一个问题：每次创建一个包后，都在为包取名时间接地指定了一个目录结构。这个包必须存在（驻留）于由它的名字规定的目录内。而且这个目录必须能从CLASSPATH开始搜索并发现。最开始的时候，package关键字的运用可能会令人迷惑，因为除非坚持遵守根据目录路径指定包名的规则，否则就会在运行期获得大量莫名其妙的消息，指出找不到一个特定的类――即使那个类明明就在相同的目录中。若得到象这样的一条消息，请试着将package语句作为注释标记出去。如果这样做行得通，就可知道问题到底出在哪儿。</p>

  <p>5.2 Java访问指示符</p>

  <p>针对类内每个成员的每个定义，Java访问指示符poublic，protected以及private都置于它们的最前面――无论它们是一个数据成员，还是一个方法。每个访问指示符都只控制着对那个特定定义的访问。这与C++存在着显著不同。在C++中，访问指示符控制着它后面的所有定义，直到又一个访问指示符加入为止。</p>

  <p>通过千丝万缕的联系，程序为所有东西都指定了某种形式的访问。在后面的小节里，大家要学习与各类访问有关的所有知识。首次从默认访问开始。</p>

  <p>5.2.1 “友好的”</p>

  <p>如果根本不指定访问指示符，就象本章之前的所有例子那样，这时会出现什么情况呢？默认的访问没有关键字，但它通常称为“友好”（Friendly）访问。这意味着当前包内的其他所有类都能访问“友好的”成员，但对包外的所有类来说，这些成员却是“私有”（Private）的，外界不得访问。由于一个编译单元（一个文件）只能从属于单个包，所以单个编译单元内的所有类相互间都是自动“友好”的。因此，我们也说友好元素拥有“包访问”权限。</p>

  <p>友好访问允许我们将相关的类都组合到一个包里，使它们相互间方便地进行沟通。将类组合到一个包内以后（这样便允许友好成员的相互访问，亦即让它们“交朋友”），我们便“拥有”了那个包内的代码。只有我们已经拥有的代码才能友好地访问自己拥有的其他代码。我们可认为友好访问使类在一个包内的组合显得有意义，或者说前者是后者的原因。在许多语言中，我们在文件内组织定义的方式往往显得有些牵强。但在Java中，却强制用一种颇有意义的形式进行组织。除此以外，我们有时可能想排除一些类，不想让它们访问当前包内定义的类。</p>

  <p>对于任何关系，一个非常重要的问题是“谁能访问我们的‘私有’或private代码”。类控制着哪些代码能够访问自己的成员。没有任何秘诀可以“闯入”。另一个包内推荐可以声明一个新类，然后说：“嗨，我是Bob的朋友！”，并指望看到Bob的“protected”（受到保护的）、友好的以及“private”（私有）的成员。为获得对一个访问权限，唯一的方法就是：</p>

  <p>(1) 使成员成为“public”（公共的）。这样所有人从任何地方都可以访问它。</p>

  <p>(2) 变成一个“友好”成员，方法是舍弃所有访问指示符，并将其类置于相同的包内。这样一来，其他类就可以访问成员。</p>

  <p>(3) 正如以后引入“继承”概念后大家会知道的那样，一个继承的类既可以访问一个protected成员，也可以访问一个public成员（但不可访问private成员）。只有在两个类位于相同的包内时，它才可以访问友好成员。但现在不必关心这方面的问题。</p>

  <p>(4) 提供“访问器／变化器”方法（亦称为“获取／设置”方法），以便读取和修改值。这是OOP环境中最正规的一种方法，也是Java Beans的基础――具体情况会在第13章介绍。</p>

  <p>5.2.2 public：接口访问</p>

  <p>使用public关键字时，它意味着紧随在public后面的成员声明适用于所有人，特别是适用于使用库的客户程序员。假定我们定义了一个名为dessert的包，其中包含下述单元（若执行该程序时遇到困难，请参考第3章3.1.2小节“赋值”）：</p>

  <p>//: Cookie.java</p>

  <p>// Creates a library</p>

  <p>package c05.dessert;</p>

  <p>public class Cookie {</p>

  <p>public Cookie() {</p>

  <p>System.out.println("Cookie constructor");</p>

  <p>}</p>

  <p>void foo() { System.out.println("foo"); }</p>

  <p>} ///:~</p>

  <p>请记住，Cookie.java必须驻留在名为dessert的一个子目录内，而这个子目录又必须位于由CLASSPATH指定的C05目录下面（C05代表本书的第5章）。不要错误地以为Java无论如何都会将当前目录作为搜索的起点看待。如果不将一个“.”作为CLASSPATH的一部分使用，Java就不会考虑当前目录。</p>

  <p>现在，假若创建使用了Cookie的一个程序，如下所示：</p>

  <p>//: Dinner.java</p>

  <p>// Uses the library</p>

  <p>import c05.dessert.*;</p>

  <p>public class Dinner {</p>

  <p>public Dinner() {</p>

  <p>System.out.println("Dinner constructor");</p>

  <p>}</p>

  <p>public static void main(String[] args) {</p>

  <p>Cookie x = new Cookie();</p>

  <p>//! x.foo(); // Can't access</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>就可以创建一个Cookie对象，因为它的构建器是public的，而且类也是public的（公共类的概念稍后还会进行更详细的讲述）。然而，foo()成员不可在Dinner.java内访问，因为foo()只有在dessert包内才是“友好”的。</p>

  <p>1. 默认包</p>

  <p>大家可能会惊讶地发现下面这些代码得以顺利编译――尽管它看起来似乎已违背了规则：</p>

  <p>//: Cake.java</p>

  <p>// Accesses a class in a separate</p>

  <p>// compilation unit.</p>

  <p>class Cake {</p>

  <p>public static void main(String[] args) {</p>

  <p>Pie x = new Pie();</p>

  <p>x.f();</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>在位于相同目录的第二个文件里：</p>

  <p>//: Pie.java</p>

  <p>// The other class</p>

  <p>class Pie {</p>

  <p>void f() { System.out.println("Pie.f()"); }</p>

  <p>} ///:~</p>

  <p>最初可能会把它们看作完全不相干的文件，然而Cake能创建一个Pie对象，并能调用它的f()方法！通常的想法会认为Pie和f()是“友好的”，所以不适用于Cake。它们确实是友好的――这部分结论非常正确。但它们之所以仍能在Cake.java中使用，是由于它们位于相同的目录中，而且没有明确的包名。Java把象这样的文件看作那个目录“默认包”的一部分，所以它们对于目录内的其他文件来说是“友好”的。</p>

  <p>5.2.3 private：不能接触！</p>

  <p>private关键字意味着除非那个特定的类，而且从那个类的方法里，否则没有人能访问那个成员。同一个包内的其他成员不能访问private成员，这使其显得似乎将类与我们自己都隔离起来。另一方面，也不能由几个合作的人创建一个包。所以private允许我们自由地改变那个成员，同时毋需关心它是否会影响同一个包内的另一个类。默认的“友好”包访问通常已经是一种适当的隐藏方法；请记住，对于包的用户来说，是不能访问一个“友好”成员的。这种效果往往能令人满意，因为默认访问是我们通常采用的方法。对于希望变成public（公共）的成员，我们通常明确地指出，令其可由客户程序员自由调用。而且作为一个结果，最开始的时候通常会认为自己不必频繁使用private关键字，因为完全可以在不用它的前提下发布自己的代码（这与C++是个鲜明的对比）。然而，随着学习的深入，大家就会发现private仍然有非常重要的用途，特别是在涉及多线程处理的时候（详情见第14章）。</p>

  <p>下面是应用了private的一个例子：</p>

  <p>//: IceCream.java</p>

  <p>// Demonstrates "private" keyword</p>

  <p>class Sundae {</p>

  <p>private Sundae() {}</p>

  <p>static Sundae makeASundae() {</p>

  <p>return new Sundae();</p>

  <p>}</p>

  <p>}</p>

  <p>public class IceCream {</p>

  <p>public static void main(String[] args) {</p>

  <p>//! Sundae x = new Sundae();</p>

  <p>Sundae x = Sundae.makeASundae();</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>这个例子向我们证明了使用private的方便：有时可能想控制对象的创建方式，并防止有人直接访问一个特定的构建器（或者所有构建器）。在上面的例子中，我们不可通过它的构建器创建一个Sundae对象；相反，必须调用makeASundae()方法来实现（注释③）。</p>

  <p>③：此时还会产生另一个影响：由于默认构建器是唯一获得定义的，而且它的属性是private，所以可防止对这个类的继承（这是第6章要重点讲述的主题）。</p>

  <p>若确定一个类只有一个“助手”方法，那么对于任何方法来说，都可以把它们设为private，从而保证自己不会误在包内其他地方使用它，防止自己更改或删除方法。将一个方法的属性设为private后，可保证自己一直保持这一选项（然而，若一个句柄被设为private，并不表明其他对象不能拥有指向同一个对象的public句柄。有关“别名”的问题将在第12章详述）。</p>

  <p>5.2.4 protected：“友好的一种”</p>

  <p>protected（受到保护的）访问指示符要求大家提前有所认识。首先应注意这样一个事实：为继续学习本书一直到继承那一章之前的内容，并不一定需要先理解本小节的内容。但为了保持内容的完整，这儿仍然要对此进行简要说明，并提供相关的例子。</p>

  <p>protected关键字为我们引入了一种名为“继承”的概念，它以现有的类为基础，并在其中加入新的成员，同时不会对现有的类产生影响――我们将这种现有的类称为“基础类”或者“基本类”（Base Class）。亦可改变那个类现有成员的行为。对于从一个现有类的继承，我们说自己的新类“扩展”（extends）了那个现有的类。如下所示：</p>

  <p>class Foo extends Bar {</p>

  <p>类定义剩余的部分看起来是完全相同的。</p>

  <p>若新建一个包，并从另一个包内的某个类里继承，则唯一能够访问的成员就是原来那个包的public成员。当然，如果在相同的包里进行继承，那么继承获得的包能够访问所有“友好”的成员。有些时候，基础类的创建者喜欢提供一个特殊的成员，并允许访问衍生类。这正是protected的工作。若往回引用5.2.2小节“public：接口访问”的那个Cookie.java文件，则下面这个类就不能访问“友好”的成员：</p>

  <p>//: ChocolateChip.java</p>

  <p>// Can't access friendly member</p>

  <p>// in another class</p>

  <p>import c05.dessert.*;</p>

  <p>public class ChocolateChip extends Cookie {</p>

  <p>public ChocolateChip() {</p>

  <p>System.out.println(</p>

  <p>"ChocolateChip constructor");</p>

  <p>}</p>

  <p>public static void main(String[] args) {</p>

  <p>ChocolateChip x = new ChocolateChip();</p>

  <p>//! x.foo(); // Can't access foo</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>对于继承，值得注意的一件有趣的事情是倘若方法foo()存在于类Cookie中，那么它也会存在于从Cookie继承的所有类中。但由于foo()在外部的包里是“友好”的，所以我们不能使用它。当然，亦可将其变成public。但这样一来，由于所有人都能自由访问它，所以可能并非我们所希望的局面。若象下面这样修改类Cookie：</p>

  <p>public class Cookie {</p>

  <p>public Cookie() {</p>

  <p>System.out.println("Cookie constructor");</p>

  <p>}</p>

  <p>protected void foo() {</p>

  <p>System.out.println("foo");</p>

  <p>}</p>

  <p>}</p>

  <p>那么仍然能在包dessert里“友好”地访问foo()，但从Cookie继承的其他东西亦可自由地访问它。然而，它并非公共的（public）。</p>

  <p>5.3 接口与实现</p>

  <p>我们通常认为访问控制是“隐藏实施细节”的一种方式。将数据和方法封装到类内后，可生成一种数据类型，它具有自己的特征与行为。但由于两方面重要的原因，访问为那个数据类型加上了自己的边界。第一个原因是规定客户程序员哪些能够使用，哪些不能。我们可在结构里构建自己的内部机制，不用担心客户程序员将其当作接口的一部分，从而自由地使用或者“滥用”。</p>

  <p>这个原因直接导致了第二个原因：我们需要将接口同实施细节分离开。若结构在一系列程序中使用，但用户除了将消息发给public接口之外，不能做其他任何事情，我们就可以改变不属于public的所有东西（如“友好的”、protected以及private），同时不要求用户对他们的代码作任何修改。</p>

  <p>我们现在是在一个面向对象的编程环境中，其中的一个类（class）实际是指“一类对象”，就象我们说“鱼类”或“鸟类”那样。从属于这个类的所有对象都共享这些特征与行为。“类”是对属于这一类的所有对象的外观及行为进行的一种描述。</p>

  <p>在一些早期OOP语言中，如Simula-67，关键字class的作用是描述一种新的数据类型。同样的关键字在大多数面向对象的编程语言里都得到了应用。它其实是整个语言的焦点：需要新建数据类型的场合比那些用于容纳数据和方法的“容器”多得多。</p>

  <p>在Java中，类是最基本的OOP概念。它是本书未采用粗体印刷的关键字之一――由于数量太多，所以会造成页面排版的严重混乱。</p>

  <p>为清楚起见，可考虑用特殊的样式创建一个类：将public成员置于最开头，后面跟随protected、友好以及private成员。这样做的好处是类的使用者可从上向下依次阅读，并首先看到对自己来说最重要的内容（即public成员，因为它们可从文件的外部访问），并在遇到非公共成员后停止阅读，后者已经属于内部实施细节的一部分了。然而，利用由javadoc提供支持的注释文档（已在第2章介绍），代码的可读性问题已在很大程度上得到了解决。</p>

  <p>public class X {</p>

  <p>public void pub1( ) { /* . . . */ }</p>

  <p>public void pub2( ) { /* . . . */ }</p>

  <p>public void pub3( ) { /* . . . */ }</p>

  <p>private void priv1( ) { /* . . . */ }</p>

  <p>private void priv2( ) { /* . . . */ }</p>

  <p>private void priv3( ) { /* . . . */ }</p>

  <p>private int i;</p>

  <p>// . . .</p>

  <p>}</p>

  <p>由于接口和实施细节仍然混合在一起，所以只是部分容易阅读。也就是说，仍然能够看到源码――实施的细节，因为它们需要保存在类里面。向一个类的消费者显示出接口实际是“类浏览器”的工作。这种工具能查找所有可用的类，总结出可对它们采取的全部操作（比如可以使用哪些成员等），并用一种清爽悦目的形式显示出来。到大家读到这本书的时候，所有优秀的Java开发工具都应推出了自己的浏览器。</p>

  <p>5.4 类访问</p>

  <p>在Java中，亦可用访问指示符判断出一个库内的哪些类可由那个库的用户使用。若想一个类能由客户程序员调用，可在类主体的起始花括号前面某处放置一个public关键字。它控制着客户程序员是否能够创建属于这个类的一个对象。</p>

  <p>为控制一个类的访问，指示符必须在关键字class之前出现。所以我们能够使用：</p>

  <p>public class Widget {</p>

  <p>也就是说，假若我们的库名是mylib，那么所有客户程序员都能访问Widget――通过下述语句：</p>

  <p>import mylib.Widget;</p>

  <p>或者</p>

  <p>import mylib.*;</p>

  <p>然而，我们同时还要注意到一些额外的限制：</p>

  <p>(1) 每个编译单元（文件）都只能有一个public类。每个编译单元有一个公共接口的概念是由那个公共类表达出来的。根据自己的需要，它可拥有任意多个提供支撑的“友好”类。但若在一个编译单元里使用了多个public类，编译器就会向我们提示一条出错消息。</p>

  <p>(2) public类的名字必须与包含了编译单元的那个文件的名字完全相符，甚至包括它的大小写形式。所以对于Widget来说，文件的名字必须是Widget.java，而不应是widget.java或者WIDGET.java。同样地，如果出现不符，就会报告一个编译期错误。</p>

  <p>(3) 可能（但并常见）有一个编译单元根本没有任何公共类。此时，可按自己的意愿任意指定文件名。</p>

  <p>如果已经获得了mylib内部的一个类，准备用它完成由Widget或者mylib内部的其他某些public类执行的任务，此时又会出现什么情况呢？我们不希望花费力气为客户程序员编制文档，并感觉以后某个时候也许会进行大手笔的修改，并将自己的类一起删掉，换成另一个不同的类。为获得这种灵活处理的能力，需要保证没有客户程序员能够依赖自己隐藏于mylib内部的特定实施细节。为达到这个目的，只需将public关键字从类中剔除即可，这样便把类变成了“友好的”（类仅能在包内使用）。</p>

  <p>注意不可将类设成private（那样会使除类之外的其他东西都不能访问它），也不能设成protected（注释④）。因此，我们现在对于类的访问只有两个选择：“友好的”或者public。若不愿其他任何人访问那个类，可将所有构建器设为private。这样一来，在类的一个static成员内部，除自己之外的其他所有人都无法创建属于那个类的一个对象（注释⑤）。如下例所示：</p>

  <p>//: Lunch.java</p>

  <p>// Demonstrates class access specifiers.</p>

  <p>// Make a class effectively private</p>

  <p>// with private constructors:</p>

  <p>class Soup {</p>

  <p>private Soup() {}</p>

  <p>// (1) Allow creation via static method:</p>

  <p>public static Soup makeSoup() {</p>

  <p>return new Soup();</p>

  <p>}</p>

  <p>// (2) Create a static object and</p>

  <p>// return a reference upon request.</p>

  <p>// (The "Singleton" pattern):</p>

  <p>private static Soup ps1 = new Soup();</p>

  <p>public static Soup access() {</p>

  <p>return ps1;</p>

  <p>}</p>

  <p>public void f() {}</p>

  <p>}</p>

  <p>class Sandwich { // Uses Lunch</p>

  <p>void f() { new Lunch(); }</p>

  <p>}</p>

  <p>// Only one public class allowed per file:</p>

  <p>public class Lunch {</p>

  <p>void test() {</p>

  <p>// Can't do this! Private constructor:</p>

  <p>//! Soup priv1 = new Soup();</p>

  <p>Soup priv2 = Soup.makeSoup();</p>

  <p>Sandwich f1 = new Sandwich();</p>

  <p>Soup.access().f();</p>

  <p>}</p>

  <p>} ///:~</p>

  <p>④：实际上，Java 1.1内部类既可以是“受到保护的”，也可以是“私有的”，但那属于特别情况。第7章会详细解释这个问题。</p>

  <p>⑤：亦可通过从那个类继承来实现。</p>

  <p>迄今为止，我们创建过的大多数方法都是要么返回void，要么返回一个基本数据类型。所以对下述定义来说：</p>

  <p>public static Soup access() {</p>

  <p>return psl;</p>

  <p>}</p>

  <p>它最开始多少会使人有些迷惑。位于方法名（access）前的单词指出方法到底返回什么。在这之前，我们看到的都是void，它意味着“什么也不返回”（void在英语里是“虚无”的意思。但亦可返回指向一个对象的句柄，此时出现的就是这个情况。该方法返回一个句柄，它指向类Soup的一个对象。</p>

  <p>Soup类向我们展示出如何通过将所有构建器都设为private，从而防止直接创建一个类。请记住，假若不明确地至少创建一个构建器，就会自动创建默认构建器（没有自变量）。若自己编写默认构建器，它就不会自动创建。把它变成private后，就没人能为那个类创建一个对象。但别人怎样使用这个类呢？上面的例子为我们揭示出了两个选择。第一个选择，我们可创建一个static方法，再通过它创建一个新的Soup，然后返回指向它的一个句柄。如果想在返回之前对Soup进行一些额外的操作，或者想了解准备创建多少个Soup对象（可能是为了限制它们的个数），这种方案无疑是特别有用的。</p>

  <p>第二个选择是采用“设计方案”（Design Pattern）技术，本书后面会对此进行详细介绍。通常方案叫作“独子”，因为它仅允许创建一个对象。类Soup的对象被创建成Soup的一个static private成员，所以有一个而且只能有一个。除非通过public方法access()，否则根本无法访问它。</p>

  <p>正如早先指出的那样，如果不针对类的访问设置一个访问指示符，那么它会自动默认为“友好的”。这意味着那个类的对象可由包内的其他类创建，但不能由包外创建。请记住，对于相同目录内的所有文件，如果没有明确地进行package声明，那么它们都默认为那个目录的默认包的一部分。然而，假若那个类一个static成员的属性是public，那么客户程序员仍然能够访问那个static成员――即使它们不能创建属于那个类的一个对象。</p>

  <p>5.5 总结</p>

  <p>对于任何关系，最重要的一点都是规定好所有方面都必须遵守的界限或规则。创建一个库时，相当于建立了同那个库的用户（即“客户程序员”）的一种关系――那些用户属于另外的程序员，可能用我们的库自行构建一个应用程序，或者用我们的库构建一个更大的库。</p>

  <p>如果不制订规则，客户程序员就可以随心所欲地操作一个类的所有成员，无论我们本来愿不愿意其中的一些成员被直接操作。所有东西都在别人面前都暴露无遗。</p>

  <p>本章讲述了如何构建类，从而制作出理想的库。首先，我们讲述如何将一组类封装到一个库里。其次，我们讲述类如何控制对自己成员的访问。</p>

  <p>一般情况下，一个C程序项目会在50K到100K行代码之间的某个地方开始中断。这是由于C仅有一个“命名空间”，所以名字会开始互相抵触，从而造成额外的管理开销。而在Java中，package关键字、包命名方案以及import关键字为我们提供对名字的完全控制，所以命名冲突的问题可以很轻易地得到避免。</p>

  <p>有两方面的原因要求我们控制对成员的访问。第一个是防止用户接触那些他们不应碰的工具。对于数据类型的内部机制，那些工具是必需的。但它们并不属于用户接口的一部分，用户不必用它来解决自己的特定问题。所以将方法和字段变成“私有”（private）后，可极大方便用户。因为他们能轻易看出哪些对于自己来说是最重要的，以及哪些是自己需要忽略的。这样便简化了用户对一个类的理解。</p>

  <p>进行访问控制的第二个、也是最重要的一个原因是：允许库设计者改变类的内部工作机制，同时不必担心它会对客户程序员产生什么影响。最开始的时候，可用一种方法构建一个类，后来发现需要重新构建代码，以便达到更快的速度。如接口和实施细节早已进行了明确的分隔与保护，就可以轻松地达到自己的目的，不要求用户改写他们的代码。</p>

  <p>利用Java中的访问指示符，可有效控制类的创建者。那个类的用户可确切知道哪些是自己能够使用的，哪些则是可以忽略的。但更重要的一点是，它可确保没有任何用户能依赖一个类的基础实施机制的任何部分。作为一个类的创建者，我们可自由修改基础的实施细节，这一改变不会对客户程序员产生任何影响，因为他们不能访问类的那一部分。</p>

  <p>有能力改变基础的实施细节后，除了能在以后改进自己的设置之外，也同时拥有了“犯错误”的自由。无论当初计划与设计时有多么仔细，仍然有可能出现一些失误。由于知道自己能相当安全地犯下这种错误，所以可以放心大胆地进行更多、更自由的试验。这对自己编程水平的提高是很有帮助的，使整个项目最终能更快、更好地完成。</p>

  <p>一个类的公共接口是所有用户都能看见的，所以在进行分析与设计的时候，这是应尽量保证其准确性的最重要的一个部分。但也不必过于紧张，少许的误差仍然是允许的。若最初设计的接口存在少许问题，可考虑添加更多的方法，只要保证不删除客户程序员已在他们的代码里使用的东西。</p>

  <p>5.6 练习</p>

  <p>(1) 用public、private、protected以及“友好的”数据成员及方法成员创建一个类。创建属于这个类的一个对象，并观察在试图访问所有类成员时会获得哪种类型的编译器错误提示。注意同一个目录内的类属于“默认”包的一部分。</p>

  <p>(2) 用protected数据创建一个类。在相同的文件里创建第二个类，用一个方法操纵第一个类里的protected数据。</p>

  <p>(3) 新建一个目录，并编辑自己的CLASSPATH，以便包括那个新目录。将P.class文件复制到自己的新目录，然后改变文件名、P类以及方法名（亦可考虑添加额外的输出，观察它的运行过程）。在一个不同的目录里创建另一个程序，令其使用自己的新类。</p>

  <p>(4) 在c</p>

  <div class="mbppagebreak"></div>
</body>
</html>
